传统的创建对象的方法是直接通过 new 关键字 ,而 spring 则是通过 IOC 容器来创建对象,也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC
Spring 容器创建对象的三种方式
传统的创建对象的方法:new 关键字
这里通过 Spring 容器怎么来创建呢?
第一种方法:利用默认的构造方法
在 src 目录下新建 applicationContext.xml 文件,这是 spring 配置文件,添加如下代码:
<?xml version="1.0" encoding="UTF-8"?>
<beans p=""
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">
<!--
创建对象的第一种方式:利用无参构造器
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=""
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">
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 方法的
1.解释spring的ioc? 几种注入依赖的方式?spring的优点?
IOC你就认为他是一个生产和管理bean的容器就行了,原来需要在调用类中new的东西,现在都是有这个IOC容器进行产生,同
时,要是产生的是单例的bean,他还可以给管理bean的生命周期!
spring的IOC有三种注入方式 :
第一是根据属性注入 也叫set方法注入;
第二种是根据构造方法进行注入;
第三种是根据注解进行注入,这种方式我认为比较好,方便,要是bean多的话,使用前两种方式会使得配置文件过于臃肿。
Spring的优点:主要是根据它的IOC和AOP体现的。我感觉他就是把我们以前用到的工厂模式和代理模式进行了一个封装。
IOC主要是解决了代码的耦合性问题,而AOP是面向切面编程的最好解释!
2.解释Spring中IOC, DI, AOP
ioc就是控制翻转或是依赖注入。通俗的讲就是如果在什么地方需要一个对象,你自己不用去通过new 生成你需要的对象,
而是通过spring的bean工厂为你长生这样一个对象。
aop就是面向切面的编程。比如说你每做一次对数据库 *** 作,都要生成一句日志。如果,你对数据库的 *** 作有很多类,
那你每一类中都要写关于日志的方法。但是如果你用aop,那么你可以写一个方法,在这个方法中有关于数据库 *** 作的方法,
每一次调用这个方法的时候,就加上生成日志的 *** 作。
3.spring的ioc/aop/代理
ioc是控制反转,是spring的核心思想。通过面向接口编程来实现对业务组件的动态依赖。 aop是面向
切面编程,它并不是只在spring或者java中才有的,它和面向对象编程(oop)是相对而言的另一种编程思想。
spring在实现aop编程时利用的是java的代理机制。 个人觉得java代理机制真的是很神奇。核心内容并不多
4.spring的ioc是解耦,aop是干什么的
AOP面向切面编程 将程序中的交叉业务逻辑(比如安全,日志,事务等),封装成一个切面,然后注入到目标对象(具体业务逻辑)中去。
比如: 很多方法可能会抛异常,你要记录这个异常到日志中去,可以写个拦截器类,在这个类中记录日志,
在spring.xml中配置一个对这些要记录日志的方法的aop拦截器 在这个方法执行后调用这个拦截器,记录日志。
这样就不用每次抛异常都要手动记录日志。 spring的事务管理用到的就是aop 这样也可以提高程序的内聚性。
5.讲解一下Java中Spring中IOC和AOP
IoC:说直白点,就是通过配置文件(XML或.properties)指定需要实例化的JAVA类(类名的完整字符串),
包括该JAVA类的一组初始化值,然后我们在代码中加载该配置文件,然后通过 .getBean() 函数就可以得到一个该JAVA类的对象,
并且该对象已经根据配置文件中指定的属性值进行了初始化。
AOP:这个比IoC更简单,直白点说就是实现调用某个方法之前或/和之后,自动执行一系列自定义的语句
6.简述Spring框架中IOC和AOP
IOC:控制反转,是一种设计模式。一层含义是控制权的转移:由传统的在程序中控制依赖转移到由容器来控制;
第二层是依赖注入:将相互依赖的对象分离,在spring配置文件中描述他们的依赖关系。他们的依赖关系只在使用的时候才建立。
AOP:面向切面,是一种编程思想,OOP的延续。将系统中非核心的业务提取出来,进行单独处理。比如事务、日志和安全等。
Spring 的AOP和IOC都是为了解决系统代码耦合度过高的问题。使代码重用度高、易于维护。
不过AOP和IOC并不是spring中特有的,只是spring把他们应用的更灵活方便 。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)