工厂方法：静态工厂方法、实例工厂方法
静态工厂方法
•调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
•要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 <constrctor-arg> 元素为该方法传递方法参数.
实例工厂方法
•实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
•要声明通过实例工厂方法创建的 Bean
–在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
–在 factory-method 属性里指定该工厂方法的名称
–使用 construtor-arg 元素为工厂方法传递方法参数
科普：Static
static 是静态修饰符，可用来修饰成员变量和方法，修饰的变量和方法属于类而不属于某个实例（直接通过类名来访问），当然任何实例也能访问；static{} 则表示静态块，再jvm加载类时就会被执行且只会被执行一次。
public class Test {
private static String a = "test";
private static void testStatic(){
System.out.println("test static method");
}
// jvm加载类时候就执行
static{
System.out.println("test static{}");
}
public static void main(String[] args) {
System.out.println(Test.a);
Test.testStatic();
//实例当然也能访问
Test test = new Test();
System.out.println(test.a);
test.testStatic();
}
}用static可以修饰方法，变量，还有代码块，这些被static修饰的，都是在类加载的时候就会执行，而不是创建对象的时候。代码块扩起来，可以用来做初始话的资源加载。
package com.sf;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import static java.lang.System.out;
public class Test {
private static Map<String,String> context = new HashMap<>();
private static final String resourceName = "/test.properties";
static {
InputStream in = null;
Properties prop = new Properties();
try {
in = Test.class.getResourceAsStream(resourceName);
prop.load(in);
context.put("name",(String)prop.get("name"));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(in != null)
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static String getContext(String pro){
return context.get(pro);
}
public static void main(String[] args) {
out.println(Test.getContext("name"));
}
}
像上面这个代码中，首先用static修饰这个方法getContext，Test类中的getContext可以作为对外的工具类，外面调用时可以直接使用，不需要创建实例。
然后static修饰的变量可以供static方法使用，这里的context可以作为一种缓存使用。
static修饰的代码块就是类加载的时候执行一次取加载配置文件中的内容
static导入包，可以省去写System，你可以在下面使用out.println 直接打印
静态域
如果将域定于为static，每个类中只要有一个这样的域。而每一个对象对于所有的实例域却都有自己的一份拷贝。共享一个静态域，静态域属于一个类，而不属于任何一个独立的对象
静态常量
静态变量使用的比较少，静态常量却使用得比较多。
例如 Math中的PI
public static final double PI = 3.14159…
如果static被省略，PI就变成了Math类的一个实例域。需要通过Math类的对象访问PI，并且每一个Math对象都有它自己的一份PI拷贝。
System中的out
public static final PrintWriter out =
由于每个类对象都可以对公有域进行修改，所以，最好不要将域设计为public。然而，公有常量（即final域）却没问题。因为out被声明为final，所以，不允许再将其他打印流赋给它。
静态方法
Math.pow(x,a)
可以认为静态方法是没有this参数的方法（在一个非静态的方法中，this参数表示这个方法的隐式参数）
因为静态方法不能操作对象，所以不能再静态方法中访问实例域，但是，静态方法可以访问自身类中的静态域。
如果省略了静态方法的static修饰，需要通过类对象的引用调用这个静态方法。
建议使用类名调用静态方法，所以最好加上static修饰。
下面两种情况下使用静态方法：
一个方法不需要访问对象状态，其所需参数都是通过显示参数提供
一个方法只需要访问类的静态域
静态工厂方法：举个栗子
新建一个包命名为com.yorkmass.spring.beans.factory
在里面添加两个类：Car、StaticCarFactory，新建一个测试类Main
Car类
package com.yorkmass.spring.beans.factory;
public class Car {
private String brand;
private double price;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", price=" + price + "]";
}
public Car(){
System.out.println("Car's constructor");
}
public Car(String brand, double price) {
super();
this.brand = brand;
this.price = price;
}
}
StaticCarFactory类
package com.yorkmass.spring.beans.factory;
import java.util.HashMap;
import java.util.Map;
/**
* 静态工厂方法：直接调用某一个类的静态方法就可以返回Bean的实例
* @author Administrator
*
*/
public class StaticCarFactory {
private static Map<String,Car> cars=new HashMap<String,Car>();
static{
cars.put("audi", new Car("audi",300000));
cars.put("ford", new Car("ford",400000));
}
//静态工厂方法。
public static Car getCar(String name){
return cars.get(name);
}
}
新建一个spring配置文件，命名为：beans-factory.xml
beans-factory.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 通过静态工厂方法来配置bean,注意不是配置静态工厂方法实例，而是配置bean实例 -->
<!--
class属性：指向静态工厂方法的全类名
factor-method：指向静态工厂方法的名字
constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
-->
<bean id="car1"
class="com.yorkmass.spring.beans.factory.StaticCarFactory"
factory-method="getCar">
<constructor-arg value="ford"></constructor-arg>
</bean>
</beans>
Main类
package com.yorkmass.spring.beans.factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-factory.xml");
Car car1=(Car)ctx.getBean("car1");
System.out.println(car1);
}
}
运行结果：
一月 17, 2019 9:05:25 上午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@176fe71: startup date [Thu Jan 17 09:05:25 CST 2019]; root of context hierarchy
一月 17, 2019 9:05:26 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans-factory.xml]
Car [brand=ford, price=400000.0]实例工厂方法：举个栗子
再上面基础上创建一个类，命名为：InstanceCarFactory
InstanceCarFactory类
package com.yorkmass.spring.beans.factory;
import java.util.HashMap;
import java.util.Map;
/**
* 实例工厂方法：实例工厂的方法，即现需要创建工厂本身，在调用工厂的实例方法来返回bean的实例
* @author Administrator
*
*/
public class InstanceCarFactory {
private Map<String,Car> cars=null;
public InstanceCarFactory(){
cars=new HashMap<String,Car>();
cars.put("audi", new Car("audi",300000));
cars.put("ford", new Car("ford",400000));
}
public Car getCar(String brand){
return cars.get(brand);
}
}
beans-factory.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 通过静态工厂方法来配置bean,注意不是配置静态工厂方法实例，而是配置bean实例 -->
<!--
class属性：指向静态工厂方法的全类名
factor-method：指向静态工厂方法的名字
constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
-->
<bean id="car1"
class="com.yorkmass.spring.beans.factory.StaticCarFactory"
factory-method="getCar">
<constructor-arg value="ford"></constructor-arg>
</bean>
<!-- 配置工厂的实例 -->
<bean id="carFactory" class="com.yorkmass.spring.beans.factory.InstanceCarFactory"></bean>
<!-- 通过实例工厂方法来配置bean -->
<!--
factory-bean属性:指向实例工厂方法的bean
factory-method:指向实例工厂方法的名字
constructor-arg:如果工厂方法需要传入参数，则使用constructor-arg来配置参数
-->
<bean id="car2" factory-bean="carFactory" factory-method="getCar">
<constructor-arg value="audi"></constructor-arg>
</bean>
</beans>
Main类
package com.yorkmass.spring.beans.factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-factory.xml");
Car car1=(Car)ctx.getBean("car1");
System.out.println(car1);
Car car2=(Car)ctx.getBean("car2");
System.out.println(car2);
}
}
运行结果：
一月 17, 2019 9:35:46 上午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@176fe71: startup date [Thu Jan 17 09:35:46 CST 2019]; root of context hierarchy
一月 17, 2019 9:35:46 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans-factory.xml]
Car [brand=ford, price=400000.0]
Car [brand=audi, price=300000.0]
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
