spring工厂模式怎么实现的（利用工厂模式+反射机制+缓存机制,实现动态创建不同的数据层对象接口）

本文目录

• 利用工厂模式+反射机制+缓存机制,实现动态创建不同的数据层对象接口
• Spring详解(二)
• spring的单例模式如何实现

利用工厂模式+反射机制+缓存机制,实现动态创建不同的数据层对象接口

这是软件设计当中的术语，设计模式当中会有介绍。工厂模式 就是类似像工厂生产东西一样的意思。只需得到出厂的东西，具体怎么生产就不知道了。拿程序来说就是自己定义一个类，这个类当中会有很多方法，而这些方法就是创建对象的作用，用这个类的人只需知道调用哪个方法得到哪个具体对象，至于怎么得到就不用管了。反射机制其实也很简单，就是一个类，可以利用反射机制得到自己有多少个方法，属性，方法名等等，这时候就可以判断这个类有无这个属性。或这个方法。从而调用该方法。缓存机制的话主要作用就是缓存一些数据喽。在这里不知道他到底有什么作用。但缓存机制就是起一个缓存，然后等下次调用的时候就直接从缓存中取数据。这跟你的IE浏览器浏览网页是一个道理的。创建不同的数据层对象接口 以上几个理解了。这个也就好理解了。也就是创建一些接口来编程了。比较灵活点。具体接口的实现就交给工厂模式去实现。如果你学过SPRING的话就会明白了，spring里面就集成了这些玩意。具体的还得自己去深入了解程序了，查查资料。外人不可能说的那么详细的。自己明白了才算真正明白。

Spring详解(二)

传统的创建对象的方法是直接通过 new 关键字 ，而 spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC

Spring 容器创建对象的三种方式

传统的创建对象的方法：new 关键字

这里通过 Spring 容器怎么来创建呢？ 第一种方法：利用默认的构造方法

在 src 目录下新建 applicationContext.xml 文件，这是 spring 配置文件，添加如下代码：

《?xml version="1.0" encoding="UTF-8"?》

《beans p=""

***隐藏网址***

***隐藏网址***

***隐藏网址***

《!--

创建对象的第一种方式：利用无参构造器

id:唯一标识符

class:类的全类名

--》

/**

* Spring 容器利用构造函数创建对象

*/

@Test

public void testCreateObjectByConstrutor(){

//1、启动 spring 容器

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContext.xml");

//2、从 spring 容器中取出数据

HelloIoc IOC = (HelloIoc) context.getBean("helloIoc");

//3、通过对象调用方法

IOC.sayHello();

//利用配置文件 alias 别名属性创建对象

HelloIoc IOC2 = (HelloIoc) context.getBean("helloIoc2");

IOC2.sayHello();

}

HelloIoc.java 中手动添加无参的构造方法，然后执行上面的测试代码，会发现构造方法会在 sayHello()方法执行之前调用

《?xml version="1.0" encoding="UTF-8"?》

《beans p=""

***隐藏网址***

***隐藏网址***

***隐藏网址***

public static void main(String args) {

ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");

JavaWork javaWork=(JavaWork)ac.getBean("javaWork");

javaWork.doTest();

}

public class JavaWork {

private Tester tester;

public void setTester(Tester tester) {

this.tester = tester;

}

public void doTest(){

/*ZhangSan zhangsan=new ZhangSan();

zhangsan.test();*/

tester.test();

}

}

第二种方法：利用静态工厂方法

　　 首先创建静态工厂类 HelloStaticFactory.java

接着在 applicationContext.xml 中进行如下配置：

《!--

创建对象的第二种方式：利用静态工厂方法

factory-method：静态工厂类的获取对象的静态方法

class:静态工厂类的全类名

--》

/**

* Spring 容器利用静态工厂方法创建对象

*/

@Test

public void createObjectStaticFactory(){

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContext.xml");

HelloIoc staticFactory =

(HelloIoc) context.getBean("helloStaticFactory");

staticFactory.sayHello();

}

spring容器只负责调用静态工厂方法，而这个静态工厂方法内部实现由程序员完成

利用实例工厂方法

首先创建实例工厂类 HelloInstanceFactory .java

public class HelloInstanceFactory {

public HelloInstanceFactory(){

System.out.println("实例工厂方法构造函数");

}

//利用实例工厂方法创建对象

public HelloIoc getInstance(){

HelloIoc instanceIoc = new HelloIoc();

return instanceIoc;

}

}

接着在 applicationContext.xml 中进行如下配置：

《!--

创建对象的第三种方式：利用实例工厂方法

factory-bean:指定当前Spring中包含工厂方法的beanID

factory-method:工厂方法名称

--》

/**

* Spring 容器利用实例工厂方法创建对象

*/

@Test

public void createObjectInstanceFactory(){

ApplicationContext context =

new ClassPathXmlApplicationContext("applicationContext.xml");

HelloIoc staticFactory =

(HelloIoc) context.getBean("instance");

staticFactory.sayHello();

}

Spring 容器创建对象的时机

默认情况下，启动 spring 容器便创建对象

在spring的配置文件bean中有一个属性 lazy-init="default/true/false"

　　　　①、如果lazy-init为"default/false"在启动spring容器时创建对象（默认情况）

　　　　 ②、如果lazy-init为"true",在context.getBean时才要创建对象

在第一种情况下可以在启动spring容器的时候，检查spring容器配置文件的正确性，如果再结合tomcat,如果spring容器不能正常启动，整个tomcat就不能正常启动。但是这样的缺点是把一些bean过早的放在了内存中，如果有数据，则对内存来是一个消耗。

反过来，在第二种情况下，可以减少内存的消耗，但是不容易发现错误

spring的bean中的scope："singleton/prototype/request/session/global session"

一、默认scope的值是singleton，即产生的对象是单例的

　　applicationContext.xml 文件中配置：

//spring 容器默认产生对象是单例的 scope="singleton"

@Test

public void test_scope_single_CreateObject(){

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

HelloIoc hello1 = (HelloIoc) context.getBean("helloIoc");

HelloIoc hello2 = (HelloIoc) context.getBean("helloIoc");

System.out.println(hello1.equals(hello2)); //true

}

scope=“prototype”

　　多例模式，并且spring容器启动的时候并不会创建对象，而是在得到 bean 的时候才会创建对象

　　applicationContext.xml 文件中配置：

　总结：在单例模式下，启动 spring 容器，便会创建对象；在多例模式下，启动容器并不会创建对象，获得 bean 的时候才会创建对象

scope=“request” 每次HTTP请求都会创建一个新的bean

scope=“session”同一个HTTP Session共享一个Bean

scope=“global session” 同一个全局Session共享一个Bean，一般用于portlet应用环境

scope=“application”同一个Application 共享一个Bean

Spring 容器生命周期

/**

* Spring 容器的生命周期

* @author hadoop

*

*/

public class SpringLifeCycle {

public SpringLifeCycle(){

System.out.println("SpringLifeCycle");

}

//定义初始化方法

public void init(){

System.out.println("init...");

}

//定义销毁方法

public void destroy(){

System.out.println("destroy...");

}

public void sayHello(){

System.out.println("say Hello...");

}

}

applicationContext.xml

public void testSpringLifeCycle(){

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

SpringLifeCycle hello = (SpringLifeCycle) context.getBean("springLifeCycle");

hello.sayHello();

//销毁spring容器

ClassPathXmlApplicationContext classContext = (ClassPathXmlApplicationContext) context;

classContext.close();

}

　　1、spring容器创建对象

　　2、执行init方法

　　3、调用自己的方法

　　4、当spring容器关闭的时候执行destroy方法

注意：当scope为"prototype"时，调用 close（） 方法时是不会调用 destroy 方法的

spring的单例模式如何实现

1.spring主要运用那些设计模式:单例，工厂2.单例模式实现:核心是私有构造子通过该类的静态方法 获取唯一的对象其中主要是2种:a.饿汉式class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }}b.懒汉式class Singleton { private static Singleton instance=null; private Singleton(){} static Singleton getInstance() { if(instance==null) instance=new Singleton(); return instance; }}