首页 > 程序开发 > 软件开发 > 其他 >

Spring框架核心技术--IOC容器

2016-10-04

简单来说Spring就是处理对象的创建、以及对象的依赖关系,之前的解决方案我们都是采用entity、dao、service、servlet、Jsp分开写,并且注意这些包之间的依赖关系,现在的Spring框架使得这件事情变得十分的简单,这是功能最强大的一个框架。

简单来说Spring就是处理对象的创建、以及对象的依赖关系,之前的解决方案我们都是采用entity、dao、service、servlet、Jsp分开写,并且注意这些包之间的依赖关系,现在的Spring框架使得这件事情变得十分的简单,这是功能最强大的一个框架。Spring框架主页:www.springsource.org 。

Spring框架


Spring框架,可以解决对象创建以及对象之间的依赖关系的一种框架,且可以和其它框架一起使用,包括Spring和Struts、Spring和Hibernate框架的整合,总的来说,Spring框架是一个起到整合(粘合)作用的框架。

专业术语详解

组件/框架设计

侵入式设计
引入了框架,对现有的类的结构有影响,即需要实现或者继承某些特定的类,Struts是侵入式设计框架。 非侵入式设计
引入了框架,对现有的类结构没有影响,我们在设计时一般都是使用非侵入式设计,Hibernate是非侵入式的设计框架,Spring框架也是非侵入式设计框架。

控制反转 Inversion on Control
需要什么就创建什么,这属于需求驱动型,这是”控制正转”,而将对象的创建交给外部容器完成,这叫作控制反转,想要拿到别人创建的对象,必须有一个可以获取该对象的公用的接口。控制反转主要是用来解决对象创建的问题(对象创建交给其它容器)

依赖注入
处理对象的依赖关系,先有控制反转后才出现依赖注入。解决对象创建完之后,对象关系的处理就是依赖注入(通过set方法依赖注入)

AOP 面向切面编程
切面,简单来说可以理解为一个类,由很多重复代码形成的类。举例来说包括:事务、日志、权限等。

Spring框架六大模块功能

Spring开发步骤

下载Spring的源代码,并将其中的jar包导入到项目中
由于项目中的jar包很多,所以导入的方法与之前在小型项目中新建lib文件夹并将jar包复制进行的方法不一样,采用的方法为:新建Java项目,右键–>properties–>Java Build Path–>Add Libray–>User Libray–>next–>User Libraries–>New–>输入要新建的Library的名字,完成之后点击确定–>Add External JARs,将外部的Spring的Jar包导入到项目中,一般情况下需要建立下面的几个Jar包,要添加的Jar包见附件。
书写Spring mvc核心配置文件
该文件通常被命名为applicationConetxt.xml或者bean.xml,首先需要在该xml文件中添加schema部分,该部分的代码如下:
得到容器对象
package com.jpzhutech.spring;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class App {

    //通过工厂类得到容器创建的对象
    @Test
    public void testIOC1() throws Exception{
        //创建对象
        //User user = new User();  //在Spring之前创建对象的方法

        //现在将对象的创建交给Spring的IOC容器
        Resource resource = new ClassPathResource("com/jpzhutech/spring/applicationContext.xml");   //在这里一定要注意导入spring的包

        //创建容器对象(bean工厂),也称为IOC容器=工厂类+applicationContext.xml文件
        BeanFactory factory = new XmlBeanFactory(resource);

        //得到容器创建的对象
        User user = (User)factory.getBean("user");

        System.out.println(user);
    }

    //直接得到IOC容器对象,该方法比较方便,在后续的ssm学习中,采用该方法创建对象
    @Test
    public void testIOC2() throws Exception{
        //得到容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/jpzhutech/spring/applicationContext.xml");

        //从容器中获取bean
        User user = (User)applicationContext.getBean("user");

        System.out.println(user);
    }

}


        
           
//注意该类没有构造函数,创建对象时使用Spring的特性去创建
package com.jpzhutech.spring;
public class User {
    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) {
        this.name = name;
    }
    }
bean对象创建的细节

Spring为我们默认创建的对象时单例的,但是可以在xml中配置单例或者多例模式。多例模式只有在对象需要的时候才创建对象,而对于单例模式,在容器创建之前就已经创建好了对象,整个应用只有这一个对象,这是二者的区别。

对象创建能否写死?不能,Spring在配置文件中写入要创建的对象,随时进行更改 对象创建的细节
对象数量
action 多个 维护成员变量 此时采用prototype参数值 service 一个 不需要维护公共变量 此时采用singleton参数值 dao 一个 不需要维护公共变量 此时采用singleton参数值 创建时间
action 访问的时候创建 采用prototype参数值 service 启动的时候创建 采用singleton参数值 dao 启动的时候创建 采用singleton参数值


        
               
         
SpringIOC容器

SpringIOC容器是Spring的核心内容,作用是用于对象的创建,解决对象之间的依赖关系。

applicationContext.xml


        
          
              
          

       
        
            
            
        

        
        
            
        

         
            
              
        

        
        
        
        
        

        
        
        
            
            
                
      
Application.java
package com.jpzhutech.spring;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

@SuppressWarnings("deprecation")
public class App {

    //通过工厂类得到容器创建的对象
    @Test
    public void testIOC1() throws Exception{
        //创建对象
        //User user = new User();  //在Spring之前创建对象的方法

        //现在将对象的创建交给Spring的IOC容器
        Resource resource = new ClassPathResource("com/jpzhutech/spring/applicationContext.xml");   //在这里一定要注意导入spring的包

        //创建容器对象(bean工厂),也称为IOC容器=工厂类+applicationContext.xml文件
        BeanFactory factory = new XmlBeanFactory(resource);

        //得到容器创建的对象
        User user = (User)factory.getBean("user");

        System.out.println(user);
    }

    //直接得到IOC容器对象,该方法比较方便,在后续的ssm学习中,采用该方法创建对象
    @Test
    public void testIOC2() throws Exception{
        //得到容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/jpzhutech/spring/applicationContext.xml");

        //从容器中获取bean
        User user1 = (User)applicationContext.getBean("user1");
        User user2 = (User)applicationContext.getBean("user2");  //使用带参数的构造函数
        User user3 = (User)applicationContext.getBean("user3");  //使用带参数的构造函数
        System.out.println(user1);
        System.out.println(user2.getName()); 

        //System.out.println((String)applicationContext.getBean("str")); //使用在配置文件中创建的对象

        System.out.println(user3.getName());

        User user4 =(User)applicationContext.getBean("user4");
        System.out.println("user4对象为:"+user4);

        User user5 = (User)applicationContext.getBean("user5");
        System.out.println("user5对象为:"+user5);
    }

}
User.java
package com.jpzhutech.spring;

public class User {
    private int id;
    private String name;

    public User() {
        super();
    }


    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }


    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
ObjectFactory.java
package com.jpzhutech.spring;

public class ObjectFactory {

    //工厂实例方法创建对象
        public User getInstance(){
            return new User();
        }

        //工厂静态方法创建对象
        public static User getInstance_static(int id , String name){
            return new User(id,name);
        }
}
对象依赖关系

对象依赖关系解决的问题是如何给Spring中的属性赋值,属性赋值的方法和代码测试如下

通过构造函数 通过set方法给属性注入值 内部bean,逻辑较为复杂,一般不推荐使用 p名称空间,该方法优化leset方法给属性注入值 自动装配,该方法一般不用了解即可 注解

applicationContext.xml




        
        
        
            
            
        

        
        
        
            
            
        

        
        
        
              
               
                
                    
                
            
         

        
        
            
        
        

        
        
            
        
        

        
        
        


      
App.java
package com.jpzhutech.property;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    private ApplicationContext applicationContext;
    @Test
    public void testProperty() throws Exception{
        //创建IOC容器
        applicationContext = new ClassPathXmlApplicationContext("com/jpzhutech/property/applicationContext.xml");
        //user1通过构造函数创建对象
        User user1 = (User)applicationContext.getBean("user1");
        System.out.println("id:"+user1.getId()+" name:"+user1.getName() );


        //user2通过set方法为属性注入值
        User user2 = (User)applicationContext.getBean("user2");
        System.out.println("id:"+user2.getId()+" name:"+user2.getName());


        //user3内部bean构造对象,逻辑容易出错
        User user3 = (User)applicationContext.getBean("user3");
        System.out.println("id:"+user3.getId()+" name:"+user3.getName());

        //利用p名称空间构造对象
        User user4 = (User)applicationContext.getBean("user4");
        System.out.println("id:"+user4.getId()+" name:"+user4.getName());

        //自动装配
        User user5 = (User)applicationContext.getBean("user5");
        System.out.println("id:"+user5.getId()+" name:"+user5.getName());

        //注解方式给属性注入值

    }
}
User.java
package com.jpzhutech.property;


import javax.annotation.Resource;

import org.springframework.stereotype.Component;

@Component
public class User {
    private int id;
    @Resource   //这种注解方式是根据类型进行查找的,必须要确保该类型只有一个变量,所以我们一般情况还是要明确给出其中参数的
    private String name;

    public User() {
        super();
    }


    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
}
相关文章
最新文章
热点推荐